.TH std::shared_timed_mutex 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::shared_timed_mutex \- std::shared_timed_mutex

.SH Synopsis
   Defined in header <shared_mutex>
   class shared_timed_mutex;         \fI(since C++14)\fP

   The shared_timed_mutex class is a synchronization primitive that can be used to
   protect shared data from being simultaneously accessed by multiple threads. In
   contrast to other mutex types which facilitate exclusive access, a
   shared_timed_mutex has two levels of access:

     * exclusive - only one thread can own the mutex.
     * shared - several threads can share ownership of the same mutex.

   Shared mutexes are usually used in situations when multiple readers can access the
   same resource at the same time without causing data races, but only one writer can
   do so.

   In a manner similar to timed_mutex, shared_timed_mutex provides the ability to
   attempt to claim ownership of a shared_timed_mutex with a timeout via the
   try_lock_for(), try_lock_until(), try_lock_shared_for(), try_lock_shared_until()
   member functions.

   The shared_timed_mutex class satisfies all requirements of SharedTimedMutex and
   StandardLayoutType.

.SH Member functions

   constructor           constructs the mutex
                         \fI(public member function)\fP
   destructor            destroys the mutex
                         \fI(public member function)\fP
   operator=             not copy-assignable
   [deleted]             \fI(public member function)\fP
         Exclusive locking
   lock                  locks the mutex, blocks if the mutex is not available
                         \fI(public member function)\fP
   try_lock              tries to lock the mutex, returns if the mutex is not available
                         \fI(public member function)\fP
                         tries to lock the mutex, returns if the mutex has been
   try_lock_for          unavailable for the specified timeout duration
                         \fI(public member function)\fP
                         tries to lock the mutex, returns if the mutex has been
   try_lock_until        unavailable until specified time point has been reached
                         \fI(public member function)\fP
   unlock                unlocks the mutex
                         \fI(public member function)\fP
.SH Shared locking
                         locks the mutex for shared ownership, blocks if the mutex is
   lock_shared           not available
                         \fI(public member function)\fP
                         tries to lock the mutex for shared ownership, returns if the
   try_lock_shared       mutex is not available
                         \fI(public member function)\fP
                         tries to lock the mutex for shared ownership, returns if the
   try_lock_shared_for   mutex has been
                         unavailable for the specified timeout duration
                         \fI(public member function)\fP
                         tries to lock the mutex for shared ownership, returns if the
   try_lock_shared_until mutex has been
                         unavailable until specified time point has been reached
                         \fI(public member function)\fP
   unlock_shared         unlocks the mutex (shared ownership)
                         \fI(public member function)\fP

.SH Notes

        Feature-test macro       Value    Std           Feature
   __cpp_lib_shared_timed_mutex 201402L \fI(C++14)\fP std::shared_timed_mutex

.SH Example

    This section is incomplete
    Reason: build a motivating example

   A copy assignment operator for a class that holds resources that can handle multiple
   readers, but only one writer.


// Run this code

 #include <mutex>
 #include <shared_mutex>

 class R
 {
     mutable std::shared_timed_mutex mut;
     /* data */
 public:
     R& operator=(const R& other)
     {
         // requires exclusive ownership to write to *this
         std::unique_lock<std::shared_timed_mutex> lhs(mut, std::defer_lock);
         // requires shared ownership to read from other
         std::shared_lock<std::shared_timed_mutex> rhs(other.mut, std::defer_lock);
         std::lock(lhs, rhs);
         /* assign data */
         return *this;
     }
 };

 int main()
 {
     R r;
 }

.SH Category:
     * Todo with reason
